{
  "nbformat": 4,
  "nbformat_minor": 2,
  "metadata": {
    "colab": {
      "name": "Writing Tutorial.ipynb",
      "provenance": [],
      "collapsed_sections": [],
      "toc_visible": true,
      "include_colab_link": true
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3.7.10 64-bit ('deep': conda)"
    },
    "language_info": {
      "name": "python",
      "version": "3.7.10",
      "mimetype": "text/x-python",
      "codemirror_mode": {
        "name": "ipython",
        "version": 3
      },
      "pygments_lexer": "ipython3",
      "nbconvert_exporter": "python",
      "file_extension": ".py"
    },
    "interpreter": {
      "hash": "cf5c02c85ac9837d3ac9fdae2fcdc9d629160c773c33f8596bbd2d51f325cec5"
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "source": [
        "<a href=\"https://colab.research.google.com/github/VIGNESHinZONE/Beginners-level-ML-projects/blob/master/Writing_Tutorial.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ],
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Tutorial 33: Physics Informed Neural Networks using JaxModel & PINN_Model\n",
        " - [Vignesh Venkataraman](https://github.com/VIGNESHinZONE)\n",
        "\n",
        "\n",
        "## Contents\n",
        "\n",
        "- Physics Informed Neural Networks\n",
        "- Setup\n",
        "- Brief about Jax and Autodiff\n",
        "- Burger's Equation\n",
        "- Data Visualisation\n",
        "- Explanation of the Solution using Jax\n",
        "- Usage of PINN Model\n",
        "- Visualize the final results"
      ],
      "metadata": {
        "id": "QtfeQrPnBpLe"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "#Physics Informed Neural Networks\n",
        "\n",
        "PINNs was introduced by Maziar Raissi et. al in their paper [Physics Informed Deep Learning (Part I): Data-driven\n",
        "Solutions of Nonlinear Partial Differential Equations](https://arxiv.org/abs/1711.10561) which are used for solving supervised learning tasks and also follow an underlying differential equation derived from understanding the Physics. In more simple terms, we try solving a differential equation with a neural network and using the differential equation as the regulariser in the loss function.\n",
        "\n",
        "<br>\n",
        "\n",
        "---\n",
        "\n",
        "### Here is an illustration of PINNs using a simple differential equation-\n",
        "\n",
        "\n",
        "$\\quad \\quad \\quad \\frac{df}{dt} = f(u, t), \\quad  $ where initial condition is $\\ \\ u(t=0) = u_0$\n",
        "\n",
        "<br>\n",
        "\n",
        "\n",
        "We approximate function $u(t)$ using a Neural Network as $NN(t)$ and apply the following loss function - \n",
        "\n",
        "<br>\n",
        "\n",
        "\n",
        "  Initial Loss: $\\quad  L_0 = (NN(t=0) - u_0)^2$\n",
        "\n",
        "  Regulariser Loss:= $\\quad L_r = | \\frac{d NN (t) }{d t} - f(NN(t), t) |$\n",
        "\n",
        "<br>\n",
        "\n",
        "\n",
        "And we minimise the $Total Loss$ using Backpropagation-\n",
        "\n",
        "<br>\n",
        "\n",
        "\n",
        "  Total Loss = Initial Loss + Regulariser Loss\n",
        "\n",
        "<br>\n",
        "\n",
        "\n",
        "### Here is a technical definition of PINNs taken from the author's official blog-\n",
        "\n",
        "  $\\quad \\quad u_t + \\mathcal{N}[u] = 0,\\ x \\in \\Omega, \\ t\\in[0,T],$\n",
        "\n",
        "<br>\n",
        "\n",
        "\n",
        "where $\\ u(t,x) \\ $ denotes the latent (hidden) solution, $\\ N[⋅] \\ $ is a nonlinear differential operator, and $Ω$ is a subset of $\\ \\mathbb{R}^D \\ $ , and proceed by approximating $u(t,x)$ by a deep neural network. We define $\\ f(t,x) \\ $ to be given by\n",
        "\n",
        "<br>\n",
        " \n",
        "  $\\quad \\quad f := u_t + \\mathcal{N}[u],$\n",
        "\n",
        "<br>\n",
        "\n",
        "This assumption results in a physics informed neural network $ \\ f(t,x) \\ $. This network can be derived by the calculus on computational graphs: Backpropagation.\n",
        "\n",
        "<br>\n",
        "\n",
        "---\n",
        "\n",
        "### Useful Resources to learn more about PINNs\n",
        "\n",
        "\n",
        "- [Maziar Raissi et. al. official blog on PINNs](https://maziarraissi.github.io/PINNs/)\n",
        "- [Chris Rackauckas's lecture on PINNs lecture 3](https://github.com/mitmath/18337#lecture-3-introduction-to-scientific-machine-learning-through-physics-informed-neural-networks): these lectures are in Julia programming language but still are a great source of learning."
      ],
      "metadata": {
        "id": "zQcs3Oz1m1ud"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Setup\n"
      ],
      "metadata": {
        "id": "YoZLoq3mB1HJ"
      }
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "source": [
        "### In case if you are running this notebook in Local Machine and have CUDA installed then uncomment this below line. ###\n",
        "### Change the cuda version depending on your setup. Here Cuda 11.x is represented as `cuda111`\n",
        "# !pip install --upgrade pip\n",
        "# !pip install --upgrade \"jax[cuda111]\" -f https://storage.googleapis.com/jax-releases/jax_releases.html\n",
        "!pip install --pre deepchem[jax]\n",
        "!pip install pyDOE"
      ],
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Collecting deepchem[jax]\n",
            "  Downloading deepchem-2.5.0-py3-none-any.whl (552 kB)\n",
            "\u001b[K     |████████████████████████████████| 552 kB 5.4 MB/s \n",
            "\u001b[33mWARNING: deepchem 2.5.0 does not provide the extra 'jax'\u001b[0m\n",
            "\u001b[?25hRequirement already satisfied: joblib in /usr/local/lib/python3.7/dist-packages (from deepchem[jax]) (1.0.1)\n",
            "Requirement already satisfied: pandas in /usr/local/lib/python3.7/dist-packages (from deepchem[jax]) (1.1.5)\n",
            "Requirement already satisfied: scipy in /usr/local/lib/python3.7/dist-packages (from deepchem[jax]) (1.4.1)\n",
            "Requirement already satisfied: numpy in /usr/local/lib/python3.7/dist-packages (from deepchem[jax]) (1.19.5)\n",
            "Requirement already satisfied: scikit-learn in /usr/local/lib/python3.7/dist-packages (from deepchem[jax]) (0.22.2.post1)\n",
            "Requirement already satisfied: python-dateutil>=2.7.3 in /usr/local/lib/python3.7/dist-packages (from pandas->deepchem[jax]) (2.8.2)\n",
            "Requirement already satisfied: pytz>=2017.2 in /usr/local/lib/python3.7/dist-packages (from pandas->deepchem[jax]) (2018.9)\n",
            "Requirement already satisfied: six>=1.5 in /usr/local/lib/python3.7/dist-packages (from python-dateutil>=2.7.3->pandas->deepchem[jax]) (1.15.0)\n",
            "Installing collected packages: deepchem\n",
            "Successfully installed deepchem-2.5.0\n",
            "Collecting pyDOE\n",
            "  Downloading pyDOE-0.3.8.zip (22 kB)\n",
            "Requirement already satisfied: numpy in /usr/local/lib/python3.7/dist-packages (from pyDOE) (1.19.5)\n",
            "Requirement already satisfied: scipy in /usr/local/lib/python3.7/dist-packages (from pyDOE) (1.4.1)\n",
            "Building wheels for collected packages: pyDOE\n",
            "  Building wheel for pyDOE (setup.py) ... \u001b[?25l\u001b[?25hdone\n",
            "  Created wheel for pyDOE: filename=pyDOE-0.3.8-py3-none-any.whl size=18184 sha256=4da795f38a3c13631115b175ca51b0cca2ebc9226d122d2f90ddf4975609baaf\n",
            "  Stored in directory: /root/.cache/pip/wheels/83/ce/8a/87b25c685bfeca1872d13b8dc101e087a9c6e3fb5ebb47022a\n",
            "Successfully built pyDOE\n",
            "Installing collected packages: pyDOE\n",
            "Successfully installed pyDOE-0.3.8\n"
          ]
        }
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "k74sLLulvo1P",
        "outputId": "69f9da73-5d23-4d23-b4dd-b9768fbb8d4f"
      }
    },
    {
      "cell_type": "code",
      "execution_count": 1,
      "source": [
        "import deepchem as dc\n",
        "import os\n",
        "\n",
        "PINNs_URL = \"https://deepchemdata.s3.us-west-1.amazonaws.com/datasets/raissi_pinns_data.tar.gz\"\n",
        "dc.utils.data_utils.download_url(\n",
        "    url=PINNs_URL, dest_dir=os.getcwd())\n",
        "targz_file = os.path.join(os.getcwd(), 'raissi_pinns_data.tar.gz')\n",
        "dc.utils.data_utils.untargz_file(targz_file, os.getcwd())\n",
        "\n"
      ],
      "outputs": [
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "WARNING:absl:No GPU/TPU found, falling back to CPU. (Set TF_CPP_MIN_LOG_LEVEL=0 and rerun for more info.)\n"
          ]
        }
      ],
      "metadata": {
        "id": "rrP1qEA5odct"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Burgers Equation\n",
        "\n",
        "Burgers’ equation is a partial differential equation that was originally proposed as a simplified model of turbulence as exhibited by the full-fledged Navier-Stokes equations. It is a nonlinear equation for which exact solutions are known and is therefore important as a benchmark problem for numerical methods. [More Refrence](https://www.azimuthproject.org/azimuth/show/Burgers%27+equation)\n",
        "\n",
        "<br>\n",
        "\n",
        "Here is the differential Equation we are trying to solve\n",
        "\n",
        "  $\\begin{array}{l}\n",
        "  \\ \\ \\ u_t + u u_x - (0.01/\\pi) u_{xx} = 0,\\ \\ \\ x \\in [-1,1],\\ \\ \\ t \\in [0,1]\n",
        "  \\end{array}$\n",
        "\n",
        "<br>\n",
        "\n",
        "Here are the initial conditions\n",
        "\n",
        "  $\\ \\ \\ u(x, 0) = -\\sin(\\pi x),$\n",
        "\n",
        "  $\\ \\ \\ u(-1, t) = u(1, t) = 0.0$\n",
        "\n",
        "<br>\n",
        "\n",
        "Now let us define:\n",
        "\n",
        "  $\n",
        "  \\ \\ \\ f := u_t + u u_x - (0.01/\\pi) u_{xx},\n",
        "  $\n",
        "\n",
        "and we approximate $u(x, t)$ using Neural Network as $NN(\\theta, x, t)$ where $\\theta$ are the weights of neural networks \n",
        "\n",
        "<br>\n",
        "\n",
        "---\n",
        "\n",
        "</br>\n",
        "Now here are the three main data points that will be used for training our Neural Network to approximate $u(x,t)$\n",
        "\n",
        "\n",
        "\n",
        "1.   We will train points lying between $x \\in [-1,1]$ and $t=0$ to follow as part of the L2 Loss\n",
        "\n",
        "    $min\\ \\ _\\theta \\ \\ (NN(\\theta, x, t) + \\sin(\\pi x))^2$\n",
        "\n",
        "<br>\n",
        "\n",
        "\n",
        "2.   We will train points lying between $t \\in [0,1]$ and $x= \\pm1 $ as part of the L2 Loss\n",
        "\n",
        "    $min\\ \\ _\\theta \\ \\ (NN(\\theta, x, t) + \\sin(\\pi x))^2$\n",
        "\n",
        "<br>\n",
        "\n",
        "3.   We will train points lying between $x \\in [-1,1],\\ \\ \\ t \\in [0,1]$ as part of the regulariser loss\n",
        "\n",
        "    $f(\\theta, x, t):= \\ \\ \\frac{\\partial NN(\\theta, x, t)}{\\partial t} + NN(\\theta, x, t)\\frac{\\partial NN(\\theta, x, t)}{\\partial x} - (0.01/\\pi)\\frac{\\partial^2 NN(\\theta, x, t)}{\\partial^2 x} $\n",
        "\n",
        "    $min\\ \\ _\\theta \\ \\ f(\\theta, x, t)$\n",
        "\n",
        "</br>\n",
        "\n",
        "In this tutorial, we will be combing data conditions 1 and 2 under the same L2Loss"
      ],
      "metadata": {
        "id": "A9aeJa8HC_e9"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Data Visualisation of the Burgers Equation\n",
        "\n",
        "Now lets load the Burger's Data provided from the author. `pre_process_shock_data ` is used to load the data in a format suitable for Neural Networks. Understanding this function is not neccesary for working through the tutorials.\n"
      ],
      "metadata": {
        "id": "5naU_8Q7DMVE"
      }
    },
    {
      "cell_type": "code",
      "execution_count": 3,
      "source": [
        "## Data Preprocessing\n",
        "\n",
        "# Create Dataset\n",
        "\n",
        "import scipy.io\n",
        "from scipy.interpolate import griddata\n",
        "from pyDOE import lhs\n",
        "import numpy as np\n",
        "import random\n",
        "random.seed(0)\n",
        "np.random.seed(0)\n",
        "\n",
        "def pre_process_shock_data(N_u, N_f, t, x, Exact):\n",
        "\n",
        "\n",
        "  X, T = np.meshgrid(x,t)\n",
        "\n",
        "  X_star = np.hstack((X.flatten()[:,None], T.flatten()[:,None]))\n",
        "  u_star = Exact.flatten()[:,None]              \n",
        "\n",
        "  # Doman bounds\n",
        "  lb = X_star.min(0)\n",
        "  ub = X_star.max(0)    \n",
        "\n",
        "  xx1 = np.hstack((X[0:1,:].T, T[0:1,:].T))\n",
        "  uu1 = Exact[0:1,:].T\n",
        "  xx2 = np.hstack((X[:,0:1], T[:,0:1]))\n",
        "  uu2 = Exact[:,0:1]\n",
        "  xx3 = np.hstack((X[:,-1:], T[:,-1:]))\n",
        "  uu3 = Exact[:,-1:]\n",
        "\n",
        "  X_u_train = np.vstack([xx1, xx2, xx3])\n",
        "  X_f_train = lb + (ub-lb)*lhs(2, N_f)\n",
        "  X_f_train = np.vstack((X_f_train, X_u_train))\n",
        "  u_train = np.vstack([uu1, uu2, uu3])\n",
        "\n",
        "  idx = np.random.choice(X_u_train.shape[0], N_u, replace=False)\n",
        "  X_u_train = X_u_train[idx, :]\n",
        "  u_train = u_train[idx,:]\n",
        "  return X_u_train, u_train, X_f_train, X_star, (X, T)\n",
        "\n",
        "\n",
        "mat_data = scipy.io.loadmat(os.path.join(os.getcwd(), 'PINNs/burgers_shock.mat'))\n",
        "\n",
        "N_u = 100\n",
        "N_f = 10000\n",
        "\n",
        "t = mat_data['t'].flatten()[:,None]\n",
        "x = mat_data['x'].flatten()[:,None]\n",
        "Exact = np.real(mat_data['usol']).T\n",
        "\n",
        "labeled_X, labeled_y, unlabeled_X, full_domain, meshgrid = pre_process_shock_data(N_u, N_f, t, x, Exact)"
      ],
      "outputs": [],
      "metadata": {
        "id": "BPCYI5A302F5"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "We have three Numpy arrays `labeled_X`, `labeled_y` and `unlabeled_X` which will be used for training our neural network,\n",
        "\n",
        "1) `labeled_X` consists of  $x \\in [-1,1]$ & $t=0$ and $t \\in [0,1]$ & $x= \\pm1 $. `labeled_y` has the value of $u(x, t)$:\n",
        "\n",
        "Let us verify that `labeled_X` & `labeled_y` also consists of data points satisfying the condition of \n",
        "\n",
        "  $\\ \\ \\ u(x, 0) = -\\sin(\\pi x), \\quad \\quad x \\in [-1,1]$ & $t=0$\n",
        "\n"
      ],
      "metadata": {
        "id": "rVJL8882R3_-"
      }
    },
    {
      "cell_type": "code",
      "execution_count": 4,
      "source": [
        "import matplotlib.pyplot as plt\n",
        "ind = labeled_X[:, 1] == 0.0\n",
        "print(f\"Number of Datapoints with with t = 0 is {len(labeled_X[labeled_X[:, 1] == 0.0])}\")\n",
        "plt.scatter(labeled_X[ind][:, 0], labeled_y[ind], color = 'red', marker = \"o\", alpha = 0.3)\n"
      ],
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Number of Datapoints with with t = 0 is 54\n"
          ]
        },
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "<matplotlib.collections.PathCollection at 0x7f6b803ae1d0>"
            ]
          },
          "metadata": {},
          "execution_count": 4
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ],
            "image/png": "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"
          },
          "metadata": {
            "needs_background": "light"
          }
        }
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 282
        },
        "id": "gm6Grl0M9xee",
        "outputId": "31b8aac4-da13-4cfe-e764-1c77c046811b"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "\n",
        "\n",
        "Let us verify that at `labeled_X` & `labeled_y` also consists of datapoints satisfying the condition of \n",
        "\n",
        "  $\\ \\ \\ u(-1, t) = u(1, t) = 0.0, \\quad \\quad t \\in [0,1]$ & $x= \\pm1$\n"
      ],
      "metadata": {
        "id": "YSUzLfi5VUUA"
      }
    },
    {
      "cell_type": "code",
      "execution_count": 5,
      "source": [
        "ind = np.abs(labeled_X[:, 0]) == 1.0\n",
        "print(f\"Number of Datapoints with with |x| = 1 is {len(labeled_X[np.abs(labeled_X[:, 0]) == 1.0])}\")\n",
        "np.max(labeled_y[ind]), np.min(labeled_y[ind]), np.mean(labeled_y[ind])\n"
      ],
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Number of Datapoints with with |x| = 1 is 46\n"
          ]
        },
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "(2.326502818752141e-16, -1.0854441803149965e-16, 8.236830416577723e-17)"
            ]
          },
          "metadata": {},
          "execution_count": 5
        }
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "gnbzgRQb-3NC",
        "outputId": "6cdf59b8-6a31-494b-ee7a-c0ab3208c7f4"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Explanation of the solution\n",
        "\n",
        "We will be using Deepchem's `PINNModel` class to solve Burger's Equation which is based out of `Jax` library. We will approximate $u(x, t)$ using a Neural Network represented as $NN(\\theta, x, t)$\n",
        "\n",
        "For our purpose, we will be using the Haiku library for building neural networks. Due to the functional nature of Jax, we define neural network with two things\n",
        "\n",
        "- Parameters - which act as the weight matrices, upon which Backpropagation is applied for optimisation.\n",
        "- forward_fn - This defines how the weights are used for computing the outputs. Ex- Feedforward, Convolution, etc\n",
        "\n",
        "\n"
      ],
      "metadata": {
        "id": "ndR7ndNLDbiz"
      }
    },
    {
      "cell_type": "code",
      "execution_count": 6,
      "source": [
        "import jax\n",
        "import jax.numpy as jnp\n",
        "import haiku as hk\n",
        "\n",
        "def f(x, t):\n",
        "  x = jnp.hstack([x, t])\n",
        "  net = hk.nets.MLP(output_sizes = [20, 20, 20, 20, 20, 20, 20, 20, 1],\n",
        "                    activation = jnp.tanh)\n",
        "  return net(x)\n",
        "\n",
        "init_params, forward_fn = hk.transform(f)\n",
        "rng = jax.random.PRNGKey(500)\n",
        "x_init, t_init = jnp.split(labeled_X, 2, 1)\n",
        "params = init_params(rng, x_init, t_init)\n"
      ],
      "outputs": [],
      "metadata": {
        "id": "ht0fLWSQkMW2"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "As per the docstrings of PINNModel, we require two additional functions in the given format - \n",
        "\n",
        "1. Create a gradient_fn which tells us about how to compute the gradients of the function-\n",
        "```\n",
        "  >>>\n",
        "  >> def gradient_fn(forward_fn, loss_outputs, initial_data):\n",
        "  >>  def model_loss(params, target, weights, rng, ...):\n",
        "  >>    # write code using the arguments.\n",
        "  >>    # ... indicates the variable number of positional arguments.\n",
        "  >>    return\n",
        "  >>  return model_loss\n",
        "```\n",
        "\n",
        "And to understand more about PINNModel, you can see that the same gradient_fn gets called in the code for computing the gradients.\n",
        "\n",
        "For our purpose, we have two variables $(x, t)$ and we need to tell the PINN Model how to compute the final gradient. For carrying out this process we will be using these main features from jax library for calculating the loss - \n",
        "\n",
        "1. [vmap](https://jax.readthedocs.io/en/latest/jax-101/03-vectorization.html) - This for parallelising computations in batches. We will process each row of the dataset, but it will get batched automatically using this feature. \n",
        "2. [jacrev](https://jax.readthedocs.io/en/latest/notebooks/autodiff_cookbook.html#jacobians-and-hessians-using-jacfwd-and-jacrev) - This is used to calculate the jacobian matrix. In our case, the output is a single dimension and hence it can be thought of as the gradient function. We could directly use jax's [grad](https://jax.readthedocs.io/en/latest/jax-101/01-jax-basics.html?highlight=grad#jax-first-transformation-grad) function but using `jacrev` simplifies the array shapes and hence is easier.\n",
        "\n",
        "\n",
        "We need to compute two losses for solving our differential equation-\n",
        "\n",
        "1. Initial Loss\n",
        "\n",
        "```\n",
        "u_pred = forward_fn(params, rng, x_b, t_b)\n",
        "initial_loss = jnp.mean((u_pred - boundary_target) ** 2)\n",
        "```\n",
        "\n",
        "2. Regulariser Loss\n",
        "\n",
        "This is slightly complicated as we need to compute \n",
        "\n",
        "$f(\\theta, x, t):= \\ \\ \\frac{\\partial NN(\\theta, x, t)}{\\partial t} + NN(\\theta, x, t)\\frac{\\partial NN(\\theta, x, t)}{\\partial x} - (0.01/\\pi)\\frac{\\partial^2 NN(\\theta, x, t)}{\\partial^2 x} $\n",
        "\n",
        "The partial derivative operation in the first and second terms can be calculated using `jacrev` function-\n",
        "```\n",
        "u_x, u_t = jacrev(forward_fn, argnums=(2, 3))(params, rng, x, t)\n",
        "```\n",
        "\n",
        "The second partial derivative operation in the third term can be applying `jacrev` twice-\n",
        "\n",
        "```\n",
        "u_xx = jacrev(jacrev(forward_fn, argnums=2), argnums=2)(params, rng, x, t)\n",
        "```\n"
      ],
      "metadata": {
        "id": "-fTsxSnEkYoe"
      }
    },
    {
      "cell_type": "code",
      "execution_count": 7,
      "source": [
        "from jax import jacrev\n",
        "import functools\n",
        "\n",
        "def gradient_fn(forward_fn, loss_outputs, initial_data):\n",
        "  \"\"\"\n",
        "  This function calls the gradient function, to implement the backpropogation\n",
        "  \"\"\"\n",
        "  boundary_data_x = initial_data['labeled_x']\n",
        "  boundary_data_t = initial_data['labeled_t']\n",
        "\n",
        "  boundary_target = initial_data['labeled_u']\n",
        "\n",
        "  @jax.jit\n",
        "  def model_loss(params, target, weights, rng, x_train, t_train):\n",
        "\n",
        "    @functools.partial(jax.vmap, in_axes=(None, 0, 0))\n",
        "    def small_loss(params, x, t):\n",
        "      u = forward_fn(params, rng, x, t)\n",
        "      u_x, u_t = jacrev(forward_fn, argnums=(2, 3))(params, rng, x, t)\n",
        "      u_xx = jacrev(jacrev(forward_fn, argnums=2), argnums=2)(params, rng, x, t)\n",
        "      con = 0.01/np.pi\n",
        "      return u_t + u * u_x - con * u_xx\n",
        "\n",
        "    u_pred = forward_fn(params, rng, boundary_data_x, boundary_data_t)\n",
        "    f_pred = small_loss(params, x_train, t_train)\n",
        "    loss_u = jnp.mean((u_pred - boundary_target) ** 2)\n",
        "    loss_f = jnp.mean((f_pred) ** 2)\n",
        "\n",
        "    return loss_u + loss_f\n",
        "\n",
        "  return model_loss\n",
        "\n"
      ],
      "outputs": [],
      "metadata": {
        "id": "SwTIEBChD87J"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "2. We also need to provide an eval_fn in the below-given format for computing the weights\n",
        "```\n",
        "  >>>\n",
        "  >> def create_eval_fn(forward_fn, params):\n",
        "  >>  def eval_model(..., rng=None):\n",
        "  >>    # write code here using arguments\n",
        "  >>\n",
        "  >>    return\n",
        "  >>  return eval_model\n",
        "```\n",
        "\n",
        "Like previously we have two arguments for our model $(x, t)$ which get passed in function"
      ],
      "metadata": {
        "id": "PzW60NtNpqH9"
      }
    },
    {
      "cell_type": "code",
      "execution_count": 8,
      "source": [
        "# Tells the neural network on how to perform calculation during inference\n",
        "def create_eval_fn(forward_fn, params):\n",
        "  \"\"\"\n",
        "  Calls the function to evaluate the model\n",
        "  \"\"\"\n",
        "  @jax.jit\n",
        "  def eval_model(x, t, rng=None):\n",
        "\n",
        "    res = forward_fn(params, rng, x, t)\n",
        "    return jnp.squeeze(res)\n",
        "  return eval_model\n"
      ],
      "outputs": [],
      "metadata": {
        "id": "8etgNQlNpplJ"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Usage of PINN Model\n",
        "\n",
        "We will be using optax library for performing the optimisations. PINNModel executes the codes for training the models."
      ],
      "metadata": {
        "id": "tDOgmtzmD9lp"
      }
    },
    {
      "cell_type": "code",
      "execution_count": 12,
      "source": [
        "import optax\n",
        "from deepchem.models import PINNModel\n",
        "\n",
        "scheduler = optax.piecewise_constant_schedule(\n",
        "    init_value=1e-2, \n",
        "    boundaries_and_scales={2500: 0.1, 5000: 0.1, 7500: 0.1})\n",
        "\n",
        "opt = optax.chain(\n",
        "    optax.clip_by_global_norm(1.00),\n",
        "    optax.scale_by_adam(b1=0.9, b2=0.99),\n",
        "    optax.scale_by_schedule(scheduler),\n",
        "    optax.scale(-1.0))\n",
        "\n",
        "labeled_x, labeled_t = jnp.split(labeled_X, 2, 1)\n",
        "\n",
        "boundary_data = {\n",
        "    'labeled_x': labeled_x, 'labeled_t':labeled_t, 'labeled_u': labeled_y\n",
        "}\n",
        "\n",
        "j_m = PINNModel(      \n",
        "    forward_fn = forward_fn,\n",
        "    params = params,\n",
        "    initial_data = boundary_data,\n",
        "    batch_size = 1000,\n",
        "    optimizer = opt,\n",
        "    grad_fn = gradient_fn,\n",
        "    eval_fn = create_eval_fn,\n",
        "    deterministic = True,\n",
        "    log_frequency = 1000\n",
        "    )\n",
        "\n",
        "dataset = dc.data.NumpyDataset(unlabeled_X)\n",
        "val = j_m.fit(dataset, nb_epochs=500)\n"
      ],
      "outputs": [
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "/home/vignesh/Desktop/deepchem/deepchem/deepchem/models/jax_models/pinns_model.py:157: UserWarning: PinnModel is still in active development and we could change the design of the API in the future.\n",
            "  'PinnModel is still in active development and we could change the design of the API in the future.'\n",
            "/home/vignesh/Desktop/deepchem/deepchem/deepchem/models/jax_models/jax_model.py:160: UserWarning: JaxModel is still in active development and all features may not yet be implemented\n",
            "  'JaxModel is still in active development and all features may not yet be implemented'\n"
          ]
        }
      ],
      "metadata": {
        "id": "KOHKt00FEX1H"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Visualize the final results\n",
        "\n",
        "- Code taken from authors for visualisation\n",
        "- show both graphs"
      ],
      "metadata": {
        "id": "eJ2tq2dBEYcU"
      }
    },
    {
      "cell_type": "code",
      "execution_count": 13,
      "source": [
        "test_dataset = dc.data.NumpyDataset(full_domain)\n",
        "u_pred = j_m.predict(test_dataset)\n",
        "U_pred = griddata(full_domain, u_pred.flatten(), meshgrid, method='cubic')\n",
        "Error = np.abs(Exact - U_pred)\n"
      ],
      "outputs": [],
      "metadata": {
        "id": "Wir3ADrnEfBu"
      }
    },
    {
      "cell_type": "code",
      "execution_count": 14,
      "source": [
        "\n",
        "import numpy as np\n",
        "import matplotlib.pyplot as plt\n",
        "import scipy.io\n",
        "from scipy.interpolate import griddata\n",
        "from mpl_toolkits.axes_grid1 import make_axes_locatable\n",
        "import matplotlib.gridspec as gridspec\n",
        "\n",
        "\n",
        "fig = plt.figure(figsize=(9, 5))\n",
        "ax = fig.add_subplot(111)\n",
        "\n",
        "h = ax.imshow(U_pred.T, interpolation='nearest', cmap='rainbow', \n",
        "              extent=[t.min(), t.max(), x.min(), x.max()], \n",
        "              origin='lower', aspect='auto')\n",
        "divider = make_axes_locatable(ax)\n",
        "cax = divider.append_axes(\"right\", size=\"5%\", pad=0.10)\n",
        "cbar = fig.colorbar(h, cax=cax)\n",
        "cbar.ax.tick_params(labelsize=15) \n",
        "\n",
        "ax.plot(\n",
        "    labeled_X[:,1], \n",
        "    labeled_X[:,0], \n",
        "    'kx', label = 'Data (%d points)' % (labeled_y.shape[0]), \n",
        "    markersize = 4,  # marker size doubled\n",
        "    clip_on = False,\n",
        "    alpha=1.0\n",
        ")\n",
        "\n",
        "line = np.linspace(x.min(), x.max(), 2)[:,None]\n",
        "ax.plot(t[25]*np.ones((2,1)), line, 'w-', linewidth = 1)\n",
        "ax.plot(t[50]*np.ones((2,1)), line, 'w-', linewidth = 1)\n",
        "ax.plot(t[75]*np.ones((2,1)), line, 'w-', linewidth = 1)\n",
        "\n",
        "ax.set_xlabel('$t$', size=20)\n",
        "ax.set_ylabel('$x$', size=20)\n",
        "ax.legend(\n",
        "    loc='upper center', \n",
        "    bbox_to_anchor=(0.9, -0.05), \n",
        "    ncol=5, \n",
        "    frameon=False, \n",
        "    prop={'size': 15}\n",
        ")\n",
        "ax.set_title('$u(t,x)$', fontsize = 20) # font size doubled\n",
        "ax.tick_params(labelsize=15)\n",
        "\n",
        "plt.show()\n",
        "\n",
        "\n",
        "fig = plt.figure(figsize=(14, 10))\n",
        "ax = fig.add_subplot(111)\n",
        "\n",
        "gs1 = gridspec.GridSpec(1, 3)\n",
        "gs1.update(top=1-1.0/3.0-0.1, bottom=1.0-2.0/3.0, left=0.1, right=0.9, wspace=0.5)\n",
        "\n",
        "ax = plt.subplot(gs1[0, 0])\n",
        "ax.plot(x,Exact[25,:], 'b-', linewidth = 2, label = 'Exact')       \n",
        "ax.plot(x,U_pred[25,:], 'r--', linewidth = 2, label = 'Prediction')\n",
        "ax.set_xlabel('$x$')\n",
        "ax.set_ylabel('$u(t,x)$')    \n",
        "ax.set_title('$t = 0.25$', fontsize = 15)\n",
        "ax.axis('square')\n",
        "ax.set_xlim([-1.1,1.1])\n",
        "ax.set_ylim([-1.1,1.1])\n",
        "\n",
        "for item in ([ax.title, ax.xaxis.label, ax.yaxis.label] +\n",
        "             ax.get_xticklabels() + ax.get_yticklabels()):\n",
        "    item.set_fontsize(15)\n",
        "\n",
        "ax = plt.subplot(gs1[0, 1])\n",
        "ax.plot(x,Exact[50,:], 'b-', linewidth = 2, label = 'Exact')       \n",
        "ax.plot(x,U_pred[50,:], 'r--', linewidth = 2, label = 'Prediction')\n",
        "ax.set_xlabel('$x$')\n",
        "ax.set_ylabel('$u(t,x)$')\n",
        "ax.axis('square')\n",
        "ax.set_xlim([-1.1,1.1])\n",
        "ax.set_ylim([-1.1,1.1])\n",
        "ax.set_title('$t = 0.50$', fontsize = 15)\n",
        "ax.legend(\n",
        "    loc='upper center', \n",
        "    bbox_to_anchor=(0.5, -0.15), \n",
        "    ncol=5, \n",
        "    frameon=False, \n",
        "    prop={'size': 15}\n",
        ")\n",
        "\n",
        "for item in ([ax.title, ax.xaxis.label, ax.yaxis.label] +\n",
        "             ax.get_xticklabels() + ax.get_yticklabels()):\n",
        "    item.set_fontsize(15)\n",
        "\n",
        "ax = plt.subplot(gs1[0, 2])\n",
        "ax.plot(x,Exact[75,:], 'b-', linewidth = 2, label = 'Exact')       \n",
        "ax.plot(x,U_pred[75,:], 'r--', linewidth = 2, label = 'Prediction')\n",
        "ax.set_xlabel('$x$')\n",
        "ax.set_ylabel('$u(t,x)$')\n",
        "ax.axis('square')\n",
        "ax.set_xlim([-1.1,1.1])\n",
        "ax.set_ylim([-1.1,1.1])    \n",
        "ax.set_title('$t = 0.75$', fontsize = 15)\n",
        "\n",
        "for item in ([ax.title, ax.xaxis.label, ax.yaxis.label] +\n",
        "             ax.get_xticklabels() + ax.get_yticklabels()):\n",
        "    item.set_fontsize(15)\n",
        "\n",
        "plt.show()\n",
        "\n"
      ],
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 648x360 with 2 Axes>"
            ],
            "image/png": "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"
          },
          "metadata": {
            "needs_background": "light"
          }
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 1008x720 with 3 Axes>"
            ],
            "image/png": "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"
          },
          "metadata": {
            "needs_background": "light"
          }
        }
      ],
      "metadata": {
        "id": "hJT0lSyQ7Q4N"
      }
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "source": [],
      "outputs": [],
      "metadata": {}
    }
  ]
}